1
          
          class AnalyticsController < ApplicationController
        
      
        

          1
          
            def index
        
      
        

          
          
              @analytics = User.order("confirmation_sent_at DESC").page(params[:page]).per_page(15)
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class AndroidController < ApplicationController
        
      
        

          1
          
            protect_from_forgery :except => :submission
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            helper_method :render_xform, :get_hash_from_xml, :prepare_site
        
      
        

          
          
          
        
      
        

          3
          
            expose(:collections) { Collection.accessible_by(current_ability) }
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            ODKFORM_TEMPLATE = "public/odk_form_template.xml"
        
      
        

          
          
          
        
      
        

          1
          
            def collections_json
        
      
        

          2
          
              collection_array=[]
        
      
        

          2
          
              collections.each do |collection|
        
      
        

          2
          
                collection_hash = collection.attributes
        
      
        

          2
          
                collection_hash["form"] = render_xform(collection) 
        
      
        

          2
          
                collection_array.push collection_hash
        
      
        

          
          
              end
        
      
        

          2
          
              render :json => collection_array
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def render_xform(collection)
        
      
        

          7
          
              if File.exist? ODKFORM_TEMPLATE
        
      
        

          7
          
                File.open ODKFORM_TEMPLATE, "r" do |file|
        
      
        

          7
          
                  xform = Xform.new(file.read)
        
      
        

          7
          
                  xform.render_form(collection)
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                ""
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def submission
        
      
        

          2
          
              xml_hash = HashParser.from_xml_file(params["xml_submission_file"]).values.first.merge("current_user" => current_user)
        
      
        

          2
          
              if current_user.admins?(Collection.find(xml_hash["collection_id"]))
        
      
        

          1
          
                render json: Site.create_or_update_from_hash!(xml_hash)
        
      
        

          
          
              else
        
      
        

          1
          
                render text: "User is unauthorized", status: 401 
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class Api::CollectionsController < ApplicationController
        
      
        

          1
          
            include Api::JsonHelper
        
      
        

          1
          
            include Api::GeoJsonHelper
        
      
        

          1
          
            include Concerns::CheckApiDocs
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :authenticate_api_user!
        
      
        

          1
          
            skip_before_filter  :verify_authenticity_token
        
      
        

          1
          
            before_filter :check_user_member_admin!, :only => [:update_sites]
        
      
        

          1
          
            before_filter :check_user_member!, :only => [:show, :geo_json, :get_sites_conflict, :get_some_sites]
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              render json: current_user.collections, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show
        
      
        

          23
          
              options = [:sort]
        
      
        

          
          
          
        
      
        

          23
          
              if params[:format] == 'csv' || params[:page] == 'all'
        
      
        

          15
          
                options << :all
        
      
        

          15
          
                params.delete(:page)
        
      
        

          
          
              elsif params[:format] == 'kml' || params[:format] == 'shp'
        
      
        

          2
          
                options << :require_location
        
      
        

          2
          
                options << :page
        
      
        

          
          
              else
        
      
        

          6
          
                options << :page
        
      
        

          
          
              end
        
      
        

          23
          
              @results = perform_search *options
        
      
        

          
          
          
        
      
        

          16
          
              collection.time_zone = current_user.time_zone
        
      
        

          16
          
              respond_to do |format|
        
      
        

          18
          
                format.rss { render :show, layout: false }
        
      
        

          24
          
                format.csv { collection_csv(collection, @results) }
        
      
        

          20
          
                format.json { render json: collection_json(collection, @results) }
        
      
        

          16
          
                format.kml { collection_kml(collection, @results) }
        
      
        

          18
          
                format.shp { collection_shp(collection, @results) }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          1
          
            def export_layers   
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.json {send_data layers.to_json(include: :fields.as_json(:except => [:id]), :except => [:id, :ord, :collection_id]), filename: "#{collection.name}_layers.json"}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def download_location_csv
        
      
        

          
          
              field = fields.find(params[:field])
        
      
        

          
          
              location_csv = collection.location_csv(field.config["locations"]) if field.config["locations"]
        
      
        

          
          
              send_data location_csv, type: 'text/csv', filename: "#{field.name}_locations.csv"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sample_csv
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.csv { collection_sample_csv(collection) }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def collection_sample_csv(collection)
        
      
        

          
          
              sample_csv = collection.sample_csv current_user
        
      
        

          
          
              send_data sample_csv, type: 'text/csv', filename: "#{collection.name}_sites.csv"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def count
        
      
        

          
          
              render json: perform_search(:count).total
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def geo_json
        
      
        

          
          
              @results = perform_search :page, :sort, :require_location
        
      
        

          
          
              render json: collection_geo_json(collection, @results)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_sites
        
      
        

          
          
              index = 0
        
      
        

          
          
              array_site_ids = params[:site_id].split(",")
        
      
        

          
          
              array_user_email = params[:user_email].split(",")
        
      
        

          
          
              array_site_ids.each do |el|
        
      
        

          
          
                site = Site.find_by_id(el)
        
      
        

          
          
                site.user = User.find_by_email(array_user_email[index])
        
      
        

          
          
                site.user = User.first
        
      
        

          
          
                site.lat = params[:lat]
        
      
        

          
          
                site.lng = params[:lng]
        
      
        

          
          
                if site.valid?
        
      
        

          
          
                  site.save!
        
      
        

          
          
                else
        
      
        

          
          
                  render json: site.errors.messages, status: :unprocessable_entity, :layout => false
        
      
        

          
          
                end
        
      
        

          
          
                index = index + 1
        
      
        

          
          
              end
        
      
        

          
          
              render json: {status: 201}
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_fields
        
      
        

          
          
              fields = Collection.find(params[:id]).fields
        
      
        

          
          
              list = []
        
      
        

          
          
              fields.each do |f|
        
      
        

          
          
                obj = {}
        
      
        

          
          
                obj["code"] = f.code
        
      
        

          
          
                obj["id"] = f.id
        
      
        

          
          
                obj["name"] = f.name
        
      
        

          
          
                obj["kind"] = f.kind
        
      
        

          
          
                obj["options"] = f.config["options"] if f.config["options"]
        
      
        

          
          
                list.push obj
        
      
        

          
          
              end
        
      
        

          
          
              render :json => list.to_json
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_sites_conflict
        
      
        

          
          
              if params[:con_type]
        
      
        

          
          
                sites = []
        
      
        

          
          
                con_type = params[:con_type].split(",")
        
      
        

          
          
                collection = Collection.find_by_id(params[:id])
        
      
        

          
          
                properties = collection.fields.find_by_code(params[:field_code]).id
        
      
        

          
          
                if (params[:from].blank? && params[:to].blank?)
        
      
        

          
          
                  from = parse_date_format("#{Time.now.mon}/01/#{Time.now.year}") - 1
        
      
        

          
          
                  to = parse_date_format("#{Time.now.mon}/30/#{Time.now.year}").end_of_month + 1
        
      
        

          
          
                  tmp_sites = Collection.find(params[:id]).sites.where(:created_at => from..to).each do |x|
        
      
        

          
          
                    con_type.each do |el|
        
      
        

          
          
                      if x.properties["#{properties}"] == el.to_i
        
      
        

          
          
                        sites << x
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
                  from = parse_date_format(params[:from]) - 1
        
      
        

          
          
                  to = parse_date_format(params[:to]) + 1
        
      
        

          
          
                  tmp_sites = Collection.find(params[:id]).sites.where(:created_at => from..to).each do |x|
        
      
        

          
          
                    con_type.each do |el|
        
      
        

          
          
                      if x.properties["#{properties}"] == el.to_i
        
      
        

          
          
                        sites << x
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end  
        
      
        

          
          
              else
        
      
        

          
          
                sites = Collection.find(params[:id]).sites
        
      
        

          
          
              end
        
      
        

          
          
              render :json => sites
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_some_sites
        
      
        

          1
          
              site_ids = params[:sites]
        
      
        

          1
          
              sites = Site.where("id in (" + site_ids + ")")
        
      
        

          1
          
              render :json => sites, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def parse_date_format date 
        
      
        

          
          
              array_date = date.split("-")
        
      
        

          
          
              return Date.new(array_date[2].to_i, array_date[0].to_i, array_date[1].to_i)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sites_by_term
        
      
        

          
          
              search = new_search
        
      
        

          
          
          
        
      
        

          
          
              search.full_text_search params[:term] if params[:term]
        
      
        

          
          
              search.alerted_search params[:_alert] if params[:_alert] 
        
      
        

          
          
              search.select_fields(['id', 'name', 'properties'])
        
      
        

          
          
              # search.apply_queries
        
      
        

          
          
          
        
      
        

          
          
              results = search.results.map{ |item| item["fields"]}
        
      
        

          
          
          
        
      
        

          
          
              results.each do |item|
        
      
        

          
          
                item[:value] = item["name"]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              render json: results
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def perform_search(*options)
        
      
        

          23
          
              except_params = [:action, :controller, :format, :id, :updated_since, :search, :box, :lat, :lng, :radius]
        
      
        

          
          
          
        
      
        

          23
          
              search = new_search
        
      
        

          
          
          
        
      
        

          23
          
              search.use_codes_instead_of_es_codes
        
      
        

          
          
          
        
      
        

          23
          
              if options.include? :page
        
      
        

          8
          
                search.page params[:page].to_i if params[:page]
        
      
        

          8
          
                except_params << :page
        
      
        

          
          
              elsif options.include? :count
        
      
        

          
          
                search.offset 0
        
      
        

          
          
                search.limit 0
        
      
        

          
          
              elsif options.include? :all
        
      
        

          15
          
                search.unlimited
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          23
          
              search.after params[:updated_since] if params[:updated_since]
        
      
        

          23
          
              search.full_text_search params[:search] if params[:search]
        
      
        

          23
          
              search.box *valid_box_coordinates if params[:box]
        
      
        

          
          
          
        
      
        

          23
          
              if params[:lat] || params[:lng] || params[:radius]
        
      
        

          
          
                [:lat, :lng, :radius].each do |key|
        
      
        

          
          
                  raise "Missing '#{key}' parameter" unless params[key]
        
      
        

          
          
                  raise "Missing '#{key}' value" unless !params[key].blank?
        
      
        

          
          
          
        
      
        

          
          
                end
        
      
        

          
          
                search.radius params[:lat], params[:lng], params[:radius]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          23
          
              if options.include? :require_location
        
      
        

          2
          
                search.require_location
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          23
          
              if options.include? :sort
        
      
        

          23
          
                search.sort params[:sort], params[:sort_direction] != 'desc' if params[:sort]
        
      
        

          23
          
                except_params << :sort
        
      
        

          23
          
                except_params << :sort_direction
        
      
        

          
          
              end
        
      
        

          23
          
              search.where params.except(*except_params)
        
      
        

          16
          
              search.api_results
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def valid_box_coordinates
        
      
        

          
          
              coords = params[:box].split ','
        
      
        

          
          
              raise "Expected the 'box' parameter to be four comma-separated numbers" if coords.length != 4
        
      
        

          
          
          
        
      
        

          
          
              coords.each_with_index do |coord, i|
        
      
        

          
          
                Float(coord) rescue raise "Expected #{(i + 1).ordinalize} value of 'box' parameter to be a number, not '#{coord}'"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              coords
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def collection_csv(collection, results)
        
      
        

          8
          
              sites_csv = collection.to_csv results, current_user
        
      
        

          8
          
              send_data sites_csv, type: 'text/csv', filename: "#{collection.name}_sites.csv"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def collection_shp(collection, results)
        
      
        

          2
          
              send_data collection.to_shp(results), type: 'application/zip', filename: "#{collection.id}.zip"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def collection_kml(collection, results)
        
      
        

          
          
              sites_kml = collection.to_kml results
        
      
        

          
          
              send_data sites_kml, type: 'application/vnd.google-earth.kml+xml', filename: "#{collection.name}_sites.kml"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def visible_layer_for_site    
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def check_user_member_admin!
        
      
        

          
          
              collection = Collection.find_by_id(params[:collection_id])
        
      
        

          
          
              if (current_user.collections.map(&:id).include?(params["id"].to_i)and current_user.admins?(collection))
        
      
        

          
          
                return true
        
      
        

          
          
              else
        
      
        

          
          
                return head 403
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def check_user_member!
        
      
        

          24
          
              collection = Collection.find_by_id(params[:collection_id])
        
      
        

          24
          
              if (current_user.collections.map(&:id).include?(params["id"].to_i))
        
      
        

          24
          
                return true
        
      
        

          
          
              else
        
      
        

          
          
                return head 403
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class Api::SitesController < ApplicationController
        
      
        

          1
          
            include Api::JsonHelper
        
      
        

          
          
          
        
      
        

          
          
            # before_filter :authenticate_user!
        
      
        

          
          
            # before_filter :authenticate_site_user!
        
      
        

          
          
          
        
      
        

          1
          
            before_filter  :authenticate_api_user!
        
      
        

          1
          
            before_filter  :check_user_member!
        
      
        

          
          
          
        
      
        

          1
          
            expose(:site)
        
      
        

          3
          
            expose(:collection) { site.collection }
        
      
        

          
          
          
        
      
        

          1
          
            def show
        
      
        

          2
          
              search = new_search
        
      
        

          
          
          
        
      
        

          2
          
              search.id(site.id)
        
      
        

          2
          
              @result = search.api_results[0]
        
      
        

          
          
          
        
      
        

          2
          
              respond_to do |format|
        
      
        

          4
          
                format.rss { render :show, layout: false }
        
      
        

          2
          
                format.json { render json: site_item_json(@result) }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update
        
      
        

          1
          
              site = Site.find_by_id(params[:id])
        
      
        

          1
          
              site.lat = params[:lat]
        
      
        

          1
          
              site.lng = params[:lng]
        
      
        

          1
          
              site.name = params[:name]
        
      
        

          
          
              # properties = prepare_site_property params
        
      
        

          1
          
              if params[:properties]
        
      
        

          1
          
                properties = params[:properties]
        
      
        

          1
          
                site.properties = properties
        
      
        

          
          
              end
        
      
        

          1
          
              unless current_user
        
      
        

          
          
                site.user = User.find_by_phone_number(params[:phone_number])
        
      
        

          
          
              else
        
      
        

          1
          
                site.user = current_user
        
      
        

          
          
              end
        
      
        

          1
          
              if site.valid?
        
      
        

          1
          
                site.save!
        
      
        

          1
          
                render json: {site: site, status: 201}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          1
          
              site = Site.find_by_id(params[:id])
        
      
        

          1
          
              site.destroy
        
      
        

          1
          
              render json: {site: site}
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          1
          
              site_params = {}
        
      
        

          
          
              # properties = prepare_site_property params
        
      
        

          1
          
              site_params.merge!("name" => params[:name])
        
      
        

          1
          
              site_params.merge!("lat" => params[:lat])
        
      
        

          1
          
              site_params.merge!("lng" => params[:lng])
        
      
        

          1
          
              site_params.merge!("properties" => params[:properties])
        
      
        

          1
          
              current_user = User.find_by_phone_number(params[:phone_number])
        
      
        

          1
          
              collection = Collection.find_by_id(params[:collection_id])
        
      
        

          1
          
              site = collection.sites.new(site_params.merge!(user: current_user))
        
      
        

          1
          
              if site.valid?
        
      
        

          1
          
                site.save!
        
      
        

          1
          
                current_user.site_count += 1
        
      
        

          1
          
                current_user.update_successful_outcome_status
        
      
        

          1
          
                current_user.save!(:validate => false)
        
      
        

          1
          
                render json: {site: site, status: 200}
        
      
        

          
          
              else
        
      
        

          
          
                render :text => "Error",:status => 500
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def prepare_site_property params
        
      
        

          
          
              properties = {}
        
      
        

          
          
              conflict_state_id = Field.find_by_code("con_state").id.to_s
        
      
        

          
          
              conflict_type_id = Field.find_by_code("con_type").id.to_s
        
      
        

          
          
              conflict_intensity_id = Field.find_by_code("con_intensity").id.to_s
        
      
        

          
          
              properties.merge!(conflict_state_id => params[:conflict_state])
        
      
        

          
          
              properties.merge!(conflict_type_id => params[:conflict_type])
        
      
        

          
          
              properties.merge!(conflict_intensity_id => params[:conflict_intensity])
        
      
        

          
          
          
        
      
        

          
          
              return properties
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          2
          
              builder = Collection.filter_sites(params)
        
      
        

          2
          
              sites_size = builder.size
        
      
        

          2
          
              sites_by_page  = Collection.filter_page(params[:limit], params[:offset], builder)
        
      
        

          2
          
              render :json => {:sites => sites_by_page, :total => sites_size}
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_reporter_site
        
      
        

          
          
              builder = Collection.filter_sites(params)
        
      
        

          
          
              sites_size = builder.size
        
      
        

          
          
              sites_by_page  = Collection.filter_page(params[:limit], params[:offset], builder)
        
      
        

          
          
              render :json => {:sites => sites_by_page, :total => sites_size}
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def check_user_member!
        
      
        

          7
          
              collection = Collection.find_by_id(params[:collection_id])
        
      
        

          7
          
              if (current_user.collections.map(&:id).include?(params["collection_id"].to_i))
        
      
        

          7
          
                return true
        
      
        

          
          
              else
        
      
        

          
          
                return head 403
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module Api::V1
        
      
        

          1
          
            class SitesController < ApplicationController
        
      
        

          1
          
              include Concerns::CheckApiDocs
        
      
        

          1
          
              include Api::JsonHelper
        
      
        

          
          
          
        
      
        

          1
          
              before_filter :authenticate_api_user!
        
      
        

          1
          
              before_filter :check_user_member!
        
      
        

          1
          
              skip_before_filter  :verify_authenticity_token
        
      
        

          3
          
              expose(:site) { Site.find(params[:site_id] || params[:id]) }
        
      
        

          
          
          
        
      
        

          1
          
              def index
        
      
        

          2
          
                builder = Collection.filter_sites(params)
        
      
        

          
          
          
        
      
        

          2
          
                sites_size = builder.size
        
      
        

          2
          
                sites_by_page  = Collection.filter_page_order_by_name(params[:limit], params[:offset], builder)
        
      
        

          2
          
                render :json => {:sites => sites_by_page, :total => sites_size}
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def show
        
      
        

          
          
                search = new_search
        
      
        

          
          
          
        
      
        

          
          
                search.id params[:id]
        
      
        

          
          
                result = search.ui_results.first['_source'] rescue {}
        
      
        

          
          
                render json: result
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def update
        
      
        

          1
          
                site.attributes = sanitized_site_params(false).merge(user: current_user)
        
      
        

          1
          
                if site.valid?
        
      
        

          1
          
                  site.save!
        
      
        

          1
          
                  if params[:photosToRemove]
        
      
        

          
          
                    Site::UploadUtils.purgePhotos(params[:photosToRemove])
        
      
        

          
          
                  end
        
      
        

          1
          
                  render json: site, :layout => false
        
      
        

          
          
                else
        
      
        

          
          
                  render json: site.errors.messages, status: :unprocessable_entity, :layout => false
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def create
        
      
        

          6
          
                site = build_site
        
      
        

          6
          
                create_state = site.id ? false : true #to create or update
        
      
        

          6
          
                if site.save
        
      
        

          6
          
                  if create_state
        
      
        

          5
          
                    current_user.site_count += 1
        
      
        

          5
          
                    current_user.update_successful_outcome_status
        
      
        

          5
          
                    current_user.save!(:validate => false)
        
      
        

          
          
                  end
        
      
        

          6
          
                  render json: site, status: :created
        
      
        

          
          
                else
        
      
        

          
          
                  render json: site.errors.messages, status: :unprocessable_entity
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def visible_layers_for
        
      
        

          
          
                layers = []
        
      
        

          
          
                if site.collection.site_ids_permission(current_user).include? site.id
        
      
        

          
          
                  target_fields = fields.includes(:layer).all
        
      
        

          
          
                  layers = target_fields.map(&:layer).uniq.map do |layer|
        
      
        

          
          
                    {
        
      
        

          
          
                      id: layer.id,
        
      
        

          
          
                      name: layer.name,
        
      
        

          
          
                      ord: layer.ord,
        
      
        

          
          
                    }
        
      
        

          
          
                  end
        
      
        

          
          
                  if site.collection.site_ids_write_permission(current_user).include? site.id
        
      
        

          
          
                    layers.each do |layer|
        
      
        

          
          
                      layer[:fields] = target_fields.select { |field| field.layer_id == layer[:id] }
        
      
        

          
          
                      layer[:fields].map! do |field|
        
      
        

          
          
                        {
        
      
        

          
          
                          id: field.es_code,
        
      
        

          
          
                          name: field.name,
        
      
        

          
          
                          code: field.code,
        
      
        

          
          
                          kind: field.kind,
        
      
        

          
          
                          config: field.config,
        
      
        

          
          
                          ord: field.ord,
        
      
        

          
          
                          is_mandatory: field.is_mandatory,
        
      
        

          
          
                          is_enable_field_logic: field.is_enable_field_logic,
        
      
        

          
          
                          writeable: true
        
      
        

          
          
                        }
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  elsif site.collection.site_ids_read_permission(current_user).include? site.id
        
      
        

          
          
                    layers.each do |layer|
        
      
        

          
          
                      layer[:fields] = target_fields.select { |field| field.layer_id == layer[:id] }
        
      
        

          
          
                      layer[:fields].map! do |field|
        
      
        

          
          
                        {
        
      
        

          
          
                          id: field.es_code,
        
      
        

          
          
                          name: field.name,
        
      
        

          
          
                          code: field.code,
        
      
        

          
          
                          kind: field.kind,
        
      
        

          
          
                          config: field.config,
        
      
        

          
          
                          ord: field.ord,
        
      
        

          
          
                          is_mandatory: field.is_mandatory,
        
      
        

          
          
                          is_enable_field_logic: field.is_enable_field_logic,
        
      
        

          
          
                          writeable: false
        
      
        

          
          
                        }
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                  layers.sort! { |x, y| x[:ord] <=> y[:ord] }
        
      
        

          
          
                else
        
      
        

          
          
                  layers = site.collection.visible_layers_for(current_user)
        
      
        

          
          
                end
        
      
        

          
          
                render json: layers
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def prepare_site_property params
        
      
        

          
          
                properties = {}
        
      
        

          
          
                conflict_state_id = Field.find_by_code("con_state").id.to_s
        
      
        

          
          
                conflict_type_id = Field.find_by_code("con_type").id.to_s
        
      
        

          
          
                conflict_intensity_id = Field.find_by_code("con_intensity").id.to_s
        
      
        

          
          
                properties.merge!(conflict_state_id => params[:conflict_state])
        
      
        

          
          
                properties.merge!(conflict_type_id => params[:conflict_type])
        
      
        

          
          
                properties.merge!(conflict_intensity_id => params[:conflict_intensity])
        
      
        

          
          
          
        
      
        

          
          
                return properties
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              private
        
      
        

          1
          
              def sanitized_site_params new_record
        
      
        

          7
          
                parameters = params[:site]
        
      
        

          
          
          
        
      
        

          7
          
                result = new_record ? {} : site.filter_site_by_id(params[:id])
        
      
        

          
          
          
        
      
        

          7
          
                fields = collection.fields.index_by &:es_code
        
      
        

          7
          
                site_properties = parameters.delete("properties") || {}
        
      
        

          
          
          
        
      
        

          7
          
                files = parameters.delete("files") || {}
        
      
        

          
          
                
        
      
        

          7
          
                decoded_properties = new_record ? {} : result.properties
        
      
        

          7
          
                site_properties.each_pair do |es_code, value|
        
      
        

          12
          
                  value = [ value, files[value] ] if fields[es_code].kind_of? Field::PhotoField
        
      
        

          12
          
                  decoded_properties[es_code] = fields[es_code].decode_from_ui(value) if fields[es_code]
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          7
          
                parameters["properties"] = decoded_properties
        
      
        

          7
          
                parameters
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def build_site
        
      
        

          6
          
                site = collection.is_site_exist? params[:site][:device_id], params[:site][:external_id] if params[:site][:device_id]
        
      
        

          6
          
                if site
        
      
        

          1
          
                  params[:id] = site.id
        
      
        

          1
          
                  site.attributes = sanitized_site_params(false).merge(user: current_user)
        
      
        

          
          
                else
        
      
        

          5
          
                  site = collection.sites.build sanitized_site_params(true).merge(user: current_user)
        
      
        

          
          
                end
        
      
        

          6
          
                return site
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              def check_user_member!
        
      
        

          9
          
                collection = Collection.find_by_id(params[:collection_id])
        
      
        

          9
          
                if (current_user.collections.map(&:id).include?(params["collection_id"].to_i))
        
      
        

          9
          
                  return true
        
      
        

          
          
                else
        
      
        

          
          
                  return head 403
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class ApplicationController < ActionController::Base
        
      
        

          1
          
            helper :all
        
      
        

          1
          
            protect_from_forgery
        
      
        

          
          
          
        
      
        

          1
          
            include Concerns::MobileDeviceDetection
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
            expose(:collection)
        
      
        

          27
          
            expose(:current_user_snapshot) { UserSnapshot.for current_user, collection }
        
      
        

          1
          
            expose(:collection_memberships){ collection.memberships.includes(:user) }
        
      
        

          3
          
            expose(:layers) {if !current_user_snapshot.at_present? && collection then collection.layer_histories.at_date(current_user_snapshot.snapshot.date) else collection.layers end}
        
      
        

          1
          
            expose(:layer)
        
      
        

          1
          
            expose(:fields) {if !current_user_snapshot.at_present? && collection then collection.field_histories.at_date(current_user_snapshot.snapshot.date) else collection.fields end}
        
      
        

          1
          
            expose(:activities) { current_user.activities }
        
      
        

          1
          
            expose(:thresholds) { collection.thresholds.order :ord }
        
      
        

          1
          
            expose(:threshold)
        
      
        

          1
          
            expose(:reminders) { collection.reminders }
        
      
        

          1
          
            expose(:reminder)
        
      
        

          1
          
            expose(:language) { Language.find_by_code I18n.locale.to_s }
        
      
        

          
          
          
        
      
        

          1
          
            expose(:new_search_options) do
        
      
        

          23
          
              if current_user_snapshot.at_present?
        
      
        

          23
          
                {current_user: current_user}
        
      
        

          
          
              else
        
      
        

          
          
                {snapshot_id: current_user_snapshot.snapshot.id, current_user_id: current_user.id}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          22
          
            expose(:new_search) { collection.new_search new_search_options }
        
      
        

          
          
          
        
      
        

          1
          
            rescue_from ActiveRecord::RecordNotFound do |x|
        
      
        

          2
          
              render :file => '/error/doesnt_exist_or_unauthorized', :status => 404, :layout => true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            rescue_from CanCan::AccessDenied do |exception|
        
      
        

          4
          
              render :file => '/error/doesnt_exist_or_unauthorized', :alert => exception.message, :status => :forbidden
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :set_timezone
        
      
        

          1
          
            before_filter :set_locale
        
      
        

          1
          
            before_filter :store_location
        
      
        

          1
          
            before_filter :set_request_header
        
      
        

          
          
            
        
      
        

          
          
          
        
      
        

          1
          
            def store_location
        
      
        

          108
          
              return unless request.get? 
        
      
        

          
          
              if (request.path != "/users/sign_in" &&
        
      
        

          46
          
                  request.path != "/users/sign_up" &&
        
      
        

          
          
                  request.path != "/users/password/new" &&
        
      
        

          
          
                  request.path != "/users/password/edit" &&
        
      
        

          
          
                  request.path != "/users/confirmation" &&
        
      
        

          
          
                  request.path != "/users/sign_out" &&
        
      
        

          
          
                  !request.xhr?)
        
      
        

          46
          
                session[:previous_url] = request.fullpath 
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_locale
        
      
        

          108
          
              cookies.signed[:locale] = params[:locale]  || cookies.signed[:locale] || I18n.default_locale
        
      
        

          108
          
              I18n.locale = cookies.signed[:locale]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_timezone
        
      
        

          
          
              # current_user.time_zone #=> 'London'
        
      
        

          99
          
              Time.zone = current_user.time_zone if current_user
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def setup_guest_user
        
      
        

          12
          
              u = User.new 
        
      
        

          12
          
              u.is_guest = true 
        
      
        

          
          
              # Empty membership for the current collection
        
      
        

          
          
              # This is used in SitesPermissionController.index
        
      
        

          
          
              # TODO: Manage permissions passing current_ability to client
        
      
        

          12
          
              membership = Membership.new
        
      
        

          12
          
              membership.collection_id = collection.id
        
      
        

          12
          
              u.memberships = [membership]
        
      
        

          12
          
              @guest_user = u
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def current_user
        
      
        

          631
          
              super || @guest_user
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def current_user_or_guest
        
      
        

          
          
              if user_signed_in?
        
      
        

          
          
                return if !current_user.try(:is_guest)
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              if params.has_key? "collection"
        
      
        

          
          
                return if !Collection.find(params["collection"]).public
        
      
        

          
          
                u = User.find_by_is_guest true
        
      
        

          
          
                sign_in :user, u
        
      
        

          
          
                current_user.is_login = true
        
      
        

          
          
                current_user.save!(:validate => false)
        
      
        

          
          
              else
        
      
        

          
          
                if current_user.try(:is_login)
        
      
        

          
          
                  current_user.is_login = false
        
      
        

          
          
                  current_user.save!(:validate => false)
        
      
        

          
          
                else
        
      
        

          
          
                  sign_out :user
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def after_sign_in_path_for(resource)
        
      
        

          
          
              if mobile_device?
        
      
        

          
          
                stored_location_for(resource) || mobile_collections_path
        
      
        

          
          
              else
        
      
        

          
          
                stored_location_for(resource) || collections_path
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_api_admin_user!
        
      
        

          
          
              params.delete :auth_token if current_user
        
      
        

          
          
              unless current_user
        
      
        

          
          
                basic_authentication_admin_check
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def basic_authentication_admin_check
        
      
        

          
          
              user = User.find_by_authentication_token(params.delete :auth_token) and sign_in user and user.is_super_user
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_collection_user!
        
      
        

          
          
              head :forbidden unless current_user.belongs_to?(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_collection_admin!
        
      
        

          4
          
              head :forbidden unless current_user.admins?(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_site_user!
        
      
        

          
          
              head :forbidden unless current_user.belongs_to?(site.collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show_collections_breadcrumb
        
      
        

          9
          
              @show_breadcrumb = true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show_collection_breadcrumb
        
      
        

          7
          
              show_collections_breadcrumb
        
      
        

          7
          
              add_breadcrumb I18n.t('views.collections.index.collections'), collections_path
        
      
        

          7
          
              add_breadcrumb collection.name, collections_path + "?collection_id=#{collection.id}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show_properties_breadcrumb
        
      
        

          2
          
              add_breadcrumb I18n.t('views.collections.index.properties'), collection_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_user_auth_token
        
      
        

          
          
              if current_user
        
      
        

          
          
                render :text => current_user.authentication_token, :layout => false
        
      
        

          
          
              else
        
      
        

          
          
                render :text => nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def basic_authentication_check
        
      
        

          
          
              user = User.find_by_authentication_token(params.delete :auth_token) and sign_in user
        
      
        

          
          
              http_basic_authentication unless user
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def http_basic_authentication
        
      
        

          
          
              authenticate_or_request_with_http_basic do |user, password|
        
      
        

          
          
                resource = User.find_by_email(user)
        
      
        

          
          
                if resource && resource.valid_password?(password)
        
      
        

          
          
                  sign_in resource
        
      
        

          
          
                  true
        
      
        

          
          
                else
        
      
        

          
          
                  head :forbidden
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_request_header
        
      
        

          108
          
              headers['Access-Control-Allow-Origin'] = '*' 
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Faster way to render json, using the Oj library.
        
      
        

          
          
            # There is a way to let render :json use Oj by default,
        
      
        

          
          
            # but in my tests it turned out to be slower... - Ary
        
      
        

          1
          
            def render_json(object, options = {})
        
      
        

          2
          
              options = options.merge(text: object.to_json_oj, content_type: 'application/json')
        
      
        

          2
          
              render options
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate_api_user!
        
      
        

          40
          
              params.delete :auth_token if current_user
        
      
        

          40
          
              unless current_user
        
      
        

          
          
                basic_authentication_check
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def ignore_public_attribute
        
      
        

          
          
              params[:layer].delete(:public) if params[:layer] && params[:layer][:public]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class ChannelsAccessesController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              @collections = Collection.joins(:users)
        
      
        

          
          
              @channels = Channel.where(:national_setup=>true)  if current_user.is_super_user
        
      
        

          
          
              @channels.each do |c|
        
      
        

          
          
                p c.name
        
      
        

          
          
              end
        
      
        

          
          
              @collections.each do |c|
        
      
        

          
          
                p c.name
        
      
        

          
          
                p c.users
        
      
        

          
          
              end
        
      
        

          
          
              # users = User.all()
        
      
        

          
          
              # @collections = []
        
      
        

          
          
              # users.each do |u|
        
      
        

          
          
              #   collectionsUser = Collection.joins(:memberships).where("memberships.user_id = :user_id", :user_id => u.id)
        
      
        

          
          
              #   collectionsUser.each do |c|
        
      
        

          
          
              #     @collections.push({
        
      
        

          
          
              #       user_id: u.id,
        
      
        

          
          
              #       user_email: u.email, 
        
      
        

          
          
              #       collection_id: c.id,
        
      
        

          
          
              #       collection_name: c.name, 
        
      
        

          
          
              #       is_enabled_national_gateway: c.is_enabled_national_gateway})
        
      
        

          
          
              #   end
        
      
        

          
          
              # end
        
      
        

          
          
              # p @nationalGateways
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def new
        
      
        

          
          
              @shareNationalChannel = ShareNationalChannel.new
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          
          
              @shareChannel = Collection.find(filter_params[:collection_id])
        
      
        

          
          
              p @shareChannel
        
      
        

          
          
              if @shareChannel.update_attributes(channel_ids: filter_params[:channel_id])
        
      
        

          
          
                redirect_to channels_accesses_path, notice: 'Collection updated'
        
      
        

          
          
              else
        
      
        

          
          
                flash.now[:alert] = "Failed to update collection"
        
      
        

          
          
                render :new
        
      
        

          
          
              end    
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          
          
              p current_user
        
      
        

          
          
              @collection = current_user.collections(params[:collection][:id])
        
      
        

          
          
              if @collection.update_attributes(filter_params)
        
      
        

          
          
                redirect_to national_gateways_path, notice: 'Project is granted access to the national gateway'
        
      
        

          
          
              else
        
      
        

          
          
                redirect_to national_gateways_path, alert: 'Fialed to grant access to national gateway'
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search_user
        
      
        

          
          
              users = User.
        
      
        

          
          
                where('email LIKE ?', "#{params[:term]}%").
        
      
        

          
          
                order('email')
        
      
        

          
          
          
        
      
        

          
          
              render json: users.pluck(:email)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search_collection
        
      
        

          
          
              collections = Collection.includes(:users).where('memberships.owner = ? ',1)
        
      
        

          
          
                .where('name LIKE ?', "#{params[:term]}%").
        
      
        

          
          
                order('name')
        
      
        

          
          
          
        
      
        

          
          
              render json: collections.as_json(include: :users)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          1
          
            def filter_params
        
      
        

          
          
              params.require(:collection).permit(:is_enabled_national_gateway)
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class CollectionsController < ApplicationController
        
      
        

          15
          
            before_filter :setup_guest_user, :if => Proc.new { collection }
        
      
        

          11
          
            before_filter :authenticate_user!, :except => [:render_breadcrumbs, :index, :alerted_collections], :unless => Proc.new { collection }
        
      
        

          
          
            
        
      
        

          1
          
            authorize_resource :except => [:render_breadcrumbs], :decent_exposure => true, :id_param => :collection_id
        
      
        

          
          
          
        
      
        

          1
          
            expose(:collections){
        
      
        

          11
          
              if current_user && !current_user.is_guest
        
      
        

          
          
                # public collections are accesible by all users
        
      
        

          
          
                # here we only need the ones in which current_user is a member
        
      
        

          9
          
                current_user.collections
        
      
        

          
          
              else
        
      
        

          2
          
                Collection.all
        
      
        

          
          
              end
        
      
        

          
          
            }
        
      
        

          
          
          
        
      
        

          1
          
            expose(:collections_with_snapshot) { select_each_snapshot(collections) }
        
      
        

          
          
          
        
      
        

          1
          
            before_filter :show_collections_breadcrumb, :only => [:index, :new]
        
      
        

          1
          
            before_filter :show_collection_breadcrumb, :except => [:index, :new, :create, :render_breadcrumbs]
        
      
        

          1
          
            before_filter :show_properties_breadcrumb, :only => [:members, :settings, :reminders, :quotas]
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          2
          
              if params[:name].present?
        
      
        

          
          
                render json: Collection.where("name like ?", "%#{params[:name]}%") if params[:name].present?
        
      
        

          
          
              else
        
      
        

          2
          
                add_breadcrumb I18n.t('views.collections.index.collections'), 'javascript:window.model.goToRoot()'
        
      
        

          
          
                
        
      
        

          2
          
                if current_user.is_guest
        
      
        

          2
          
                  if params[:collection_id] && !collection.public?
        
      
        

          
          
                    flash[:error] = "You need to sign in order to view this collection"
        
      
        

          
          
                    redirect_to new_user_session_url
        
      
        

          
          
                    return
        
      
        

          
          
                  end
        
      
        

          2
          
                  collections = Collection.public_collections
        
      
        

          
          
                else
        
      
        

          
          
                  collections = current_user.collections.reject{|c| c.id.nil?}
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          2
          
                respond_to do |format|
        
      
        

          2
          
                  format.html
        
      
        

          2
          
                  format.json { render json:  collections, :root => false}
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def render_breadcrumbs
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.index.collections'), 'javascript:window.model.goToRoot()' if current_user && !current_user.is_guest
        
      
        

          
          
              if params.has_key? :collection_id
        
      
        

          
          
                add_breadcrumb collection.name, 'javascript:window.model.exitSite()'
        
      
        

          
          
                if params.has_key? :site_id
        
      
        

          
          
                  add_breadcrumb params[:site_name], '#'
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              render :layout => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def new
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.index.collections'), collections_path
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.form.create_new_collection'), nil
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          1
          
              if current_user.create_collection collection
        
      
        

          1
          
                current_user.collection_count += 1
        
      
        

          1
          
                current_user.update_successful_outcome_status
        
      
        

          1
          
                current_user.save!(:validate => false)
        
      
        

          1
          
                redirect_to collection_path(collection), notice: I18n.t('views.collections.form.collection_created', name: collection.name)
        
      
        

          
          
              else
        
      
        

          
          
                render :new
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update
        
      
        

          
          
              if params[:collection][:hierarchy_mode] == "0"
        
      
        

          
          
                params[:collection][:field_identify] = ""
        
      
        

          
          
                params[:collection][:field_parent] = ""
        
      
        

          
          
              end
        
      
        

          
          
              if collection.update_attributes params[:collection]
        
      
        

          
          
                collection.recreate_index
        
      
        

          
          
                redirect_to collection_settings_path(collection), notice: I18n.t('views.collections.form.collection_updated', name: collection.name)
        
      
        

          
          
              else
        
      
        

          
          
                render :settings
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show
        
      
        

          
          
              @snapshot = Snapshot.new
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.index.properties'), '#'
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html
        
      
        

          
          
                format.json { render json: collection }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def members
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.members'), collection_members_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def reminders
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.reminders'), collection_reminders_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def settings
        
      
        

          
          
              @options_for_select = [["(no value)", ""]]
        
      
        

          
          
              collection.fields.each do |field|
        
      
        

          
          
                @options_for_select.push([field.name, field.id])
        
      
        

          
          
              end
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.settings'), collection_settings_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def quotas
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.quotas'), collection_settings_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          
          
              if params[:only_sites]
        
      
        

          
          
                collection.delete_sites_and_activities
        
      
        

          
          
                redirect_to collection_path(collection), notice: I18n.t('views.collections.form.sites_deleted', name: collection.name)
        
      
        

          
          
              else
        
      
        

          
          
                collection.update_activities
        
      
        

          
          
                collection.destroy
        
      
        

          
          
                collection.create_deleted_activity(current_user)
        
      
        

          
          
                redirect_to collections_path, notice: I18n.t('views.collections.form.collection_deleted', name: collection.name)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def csv_template
        
      
        

          
          
              send_data collection.csv_template, type: 'text/csv', filename: "collection_sites_template.csv"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def upload_csv
        
      
        

          
          
              collection.import_csv current_user, params[:file].read
        
      
        

          
          
              redirect_to collections_path
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create_snapshot
        
      
        

          
          
              @snapshot = Snapshot.create(date: Time.now, name: params[:snapshot][:name], collection: collection)
        
      
        

          
          
              if @snapshot.valid?
        
      
        

          
          
                redirect_to collection_path(collection), notice: I18n.t('views.collections.form.snapshot_created', name: params[:name])
        
      
        

          
          
              else
        
      
        

          
          
                flash[:error] = I18n.t('views.collections.form.snapshot_could_not_be_created', errors: @snapshot.errors.to_a.join(", "))
        
      
        

          
          
                redirect_to collection_path(collection)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def unload_current_snapshot
        
      
        

          1
          
              loaded_snapshot = current_user_snapshot.snapshot
        
      
        

          1
          
              current_user_snapshot.go_back_to_present!
        
      
        

          
          
          
        
      
        

          1
          
              respond_to do |format|
        
      
        

          1
          
                format.html {
        
      
        

          1
          
                  flash[:notice] = I18n.t('views.collections.form.snapshot_unloaded', name: loaded_snapshot.name) if loaded_snapshot if loaded_snapshot
        
      
        

          1
          
                  redirect_to  collection_path(collection) }
        
      
        

          1
          
                format.json { render json: :ok }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def load_snapshot
        
      
        

          
          
              if current_user_snapshot.go_to!(params[:name])
        
      
        

          
          
                redirect_to collection_path(collection), notice: I18n.t('views.collections.form.snapshot_loaded', name: params[:name])
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def max_value_of_property
        
      
        

          
          
              render json: collection.max_value_of_property(params[:property])
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def select_each_snapshot(collections)
        
      
        

          
          
              collections_with_snapshot = []
        
      
        

          
          
              collections.each do |collection|
        
      
        

          
          
                attrs = collection.attributes
        
      
        

          
          
                # If user is guest (=> current_user will be nil) she will not be able to load a snapshot. At least for the moment
        
      
        

          
          
                attrs["snapshot_name"] = collection.snapshot_for(current_user).try(:name) rescue nil
        
      
        

          
          
                collections_with_snapshot = collections_with_snapshot + [attrs]
        
      
        

          
          
              end
        
      
        

          
          
              collections_with_snapshot
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sites_by_term
        
      
        

          2
          
              search = new_search
        
      
        

          
          
          
        
      
        

          2
          
              search.full_text_search params[:term] if params[:term]
        
      
        

          2
          
              search.alerted_search params[:_alert] if params[:_alert] 
        
      
        

          2
          
              search.select_fields(['id', 'name'])
        
      
        

          5
          
              results = search.results.map { |item| item["fields"] }
        
      
        

          2
          
              results.each do |item|
        
      
        

          3
          
                item[:value] = item["name"]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              render_json results
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search
        
      
        

          
          
              search = new_search
        
      
        

          
          
          
        
      
        

          
          
              search.after params[:updated_since] if params[:updated_since]
        
      
        

          
          
              search.full_text_search params[:search]
        
      
        

          
          
              search.offset params[:offset]
        
      
        

          
          
              search.limit params[:limit]
        
      
        

          
          
              search.alerted_search params[:_alert] if params[:_alert] 
        
      
        

          
          
              search.sort params[:sort], params[:sort_direction] != 'desc' if params[:sort]
        
      
        

          
          
              search.hierarchy params[:hierarchy_code], params[:hierarchy_value] if params[:hierarchy_code]
        
      
        

          
          
              search.location_missing if params[:location_missing].present?
        
      
        

          
          
              search.where params.except(
        
      
        

          
          
                :selected_site_children, :selected_site_parent, 
        
      
        

          
          
                :action, :controller, :format, :id, :collection_id, 
        
      
        

          
          
                :updated_since, :search, :limit, :offset, :sort, :sort_direction, 
        
      
        

          
          
                :hierarchy_code, :hierarchy_value, :location_missing, :_alert
        
      
        

          
          
              )
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
              # search.apply_queries
        
      
        

          
          
          
        
      
        

          
          
              results = search.results.map do |result|
        
      
        

          
          
                source = result['_source']
        
      
        

          
          
          
        
      
        

          
          
                obj = {}
        
      
        

          
          
                obj[:id] = source['id']
        
      
        

          
          
                obj[:name] = source['name']
        
      
        

          
          
                obj[:created_at] = Site.parse_time(source['created_at'])
        
      
        

          
          
                obj[:updated_at] = Site.parse_time(source['updated_at'])
        
      
        

          
          
          
        
      
        

          
          
                if source['location']
        
      
        

          
          
                  obj[:lat] = source['location']['lat']
        
      
        

          
          
                  obj[:lng] = source['location']['lon']
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                if source['properties']
        
      
        

          
          
                  obj[:properties] = source['properties']
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                obj
        
      
        

          
          
              end
        
      
        

          
          
              render json: results, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def decode_hierarchy_csv
        
      
        

          
          
              csv_string = File.read(params[:file].path, :encoding => 'utf-8')
        
      
        

          
          
              @hierarchy = collection.decode_hierarchy_csv(csv_string)
        
      
        

          
          
              @hierarchy_errors = CollectionsController.generate_error_description_list(@hierarchy)
        
      
        

          
          
              render layout: false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def decode_location_csv
        
      
        

          
          
              csv_string = File.read(params[:file].path, :encoding => 'utf-8')
        
      
        

          
          
              @locations = collection.decode_location_csv(csv_string)
        
      
        

          
          
              @locations_errors = CollectionsController.generate_error_description_location(@locations)
        
      
        

          
          
              render layout: false
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          1
          
            def self.generate_error_description_location(locations_csv)
        
      
        

          
          
              locations_errors = []
        
      
        

          
          
              locations_csv.each do |item|
        
      
        

          
          
                message = ""
        
      
        

          
          
          
        
      
        

          
          
                if item[:error]
        
      
        

          
          
                  message << "Error: #{item[:error]}"
        
      
        

          
          
                  message << " " + item[:error_description] if item[:error_description]
        
      
        

          
          
                  message << " in line #{item[:order]}." if item[:order]
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                locations_errors << message if !message.blank?
        
      
        

          
          
              end
        
      
        

          
          
              locations_errors.join("<br/>").to_s
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def self.generate_error_description_list(hierarchy_csv)
        
      
        

          3
          
              hierarchy_errors = []
        
      
        

          3
          
              hierarchy_csv.each do |item|
        
      
        

          5
          
                message = ""
        
      
        

          5
          
                if item[:error]
        
      
        

          4
          
                  message << "Error: #{item[:error]}"
        
      
        

          4
          
                  message << " " + item[:error_description] if item[:error_description]
        
      
        

          4
          
                  message << " in line #{item[:order]}." if item[:order]
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          5
          
                hierarchy_errors << message if !message.blank?
        
      
        

          
          
              end
        
      
        

          3
          
              hierarchy_errors.join("<br/>").to_s
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def recreate_index
        
      
        

          
          
              render json: collection.recreate_index
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def register_gateways
        
      
        

          
          
              channels = []
        
      
        

          
          
              channels = Channel.find params[:gateways] if params[:gateways].present?
        
      
        

          
          
              collection.channels = channels
        
      
        

          
          
              render json: collection.as_json
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def message_quota
        
      
        

          
          
              date = Date.today
        
      
        

          
          
              case params[:filter_type]
        
      
        

          
          
              when "week"
        
      
        

          
          
                start_date = date - 7
        
      
        

          
          
              when "month"
        
      
        

          
          
                start_date = date.prev_month
        
      
        

          
          
              else
        
      
        

          
          
                start_date = date.prev_year
        
      
        

          
          
              end
        
      
        

          
          
              ms = collection.messages.where("is_send = true and created_at between ? and ?", start_date, Time.now)
        
      
        

          
          
              render json: {status: 200, remain_quota: collection.quota, sended_message: ms.length }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def alerted_collections
        
      
        

          
          
              collections = Collection.find_all_by_id params[:ids]
        
      
        

          
          
              ids = collections.map do |c|
        
      
        

          
          
                s = c.new_search
        
      
        

          
          
                s.alerted_search true
        
      
        

          
          
                # s.apply_queries
        
      
        

          
          
                c.id if s.results.length > 0 
        
      
        

          
          
              end
        
      
        

          
          
              render json: ids.compact, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def send_new_member_sms
        
      
        

          
          
              random_code = (0..3).map{(rand(9))}.join
        
      
        

          
          
              method = Channel.nuntium_info_methods
        
      
        

          
          
              collection = Collection.find_by_id(params[:collection_id])
        
      
        

          
          
              if channel = collection.channels.first
        
      
        

          
          
                channel_detail = channel.as_json(methods: method)
        
      
        

          
          
                if channel_detail[:client_connected]
        
      
        

          
          
                  SmsNuntium.notify_sms [params[:phone_number]], "Your single-use Resource Map pin code is #{random_code}", channel.nuntium_channel_name, nil
        
      
        

          
          
                  render json: {status: 200, secret_code: random_code}
        
      
        

          
          
                else
        
      
        

          
          
                  render json: {status: 'channel_disconnected', notice: 'The channel is disconnected.'}
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                render json: {status: 'no_channel', notice: 'There is no channel on the collection.'}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sites_info
        
      
        

          2
          
              options = new_search_options
        
      
        

          
          
          
        
      
        

          2
          
              total = collection.elasticsearch_count
        
      
        

          2
          
              no_location = collection.elasticsearch_count do
        
      
        

          
          
                {
        
      
        

          
          
                  query: {
        
      
        

          
          
                    filtered: {
        
      
        

          
          
                      filter: {
        
      
        

          
          
                        not: {
        
      
        

          
          
                          filter: {
        
      
        

          
          
                            exists: {field: :location}
        
      
        

          
          
                          }
        
      
        

          
          
                        }
        
      
        

          
          
                      }
        
      
        

          
          
                    }
        
      
        

          
          
                  }
        
      
        

          2
          
                }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          2
          
              info = {}
        
      
        

          2
          
              info[:total] = total
        
      
        

          2
          
              info[:no_location] = no_location > 0
        
      
        

          2
          
              info[:new_site_properties] = collection.new_site_properties
        
      
        

          
          
          
        
      
        

          2
          
              render json: info
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module Concerns::CheckApiDocs
        
      
        

          1
          
            extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          1
          
            included do
        
      
        

          2
          
              around_filter :rescue_with_check_api_docs
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def rescue_with_check_api_docs
        
      
        

          33
          
              yield
        
      
        

          
          
            rescue => ex
        
      
        

          
          
          
        
      
        

          9
          
              Rails.logger.info ex.message
        
      
        

          9
          
              Rails.logger.info ex.backtrace
        
      
        

          
          
          
        
      
        

          9
          
              render text: "#{ex.message} - Check the API documentation: https://bitbucket.org/ilab/resource_map_sea/wiki/API", status: 400
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module Concerns::MobileDeviceDetection
        
      
        

          1
          
            extend ActiveSupport::Concern
        
      
        

          
          
          
        
      
        

          1
          
            included do
        
      
        

          1
          
              helper_method :mobile_device?
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def mobile_device?  
        
      
        

          
          
              if params[:_desktop] == "1" || params[:_desktop] == "true"
        
      
        

          
          
                return false
        
      
        

          
          
              else
        
      
        

          
          
                session[:desktop_param] = false
        
      
        

          
          
                from_mobile_browser? || session[:mobile_param] == "1" 
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def from_mobile_browser?
        
      
        

          
          
              !!(request.user_agent =~ /Mobile|webOS/)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def prepare_for_mobile
        
      
        

          
          
              session[:mobile_param] = params[:mobile] if params[:mobile]
        
      
        

          
          
              request.format = :mobile if mobile_device?
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class GatewaysController < ApplicationController
        
      
        

          1
          
            before_filter :setup_guest_user, :only => :index
        
      
        

          1
          
            before_filter :authenticate_user!, :except => :index
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              method = Channel.nuntium_info_methods
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html 
        
      
        

          
          
                format.json { render json: (params[:without_nuntium] ?  current_user.channels.where("channels.is_enable=?", true).all.as_json : current_user.channels.select('channels.id,channels.name,channels.password,channels.is_enable,channels.basic_setup, channels.advanced_setup, channels.national_setup').all.as_json(methods: method)), :root => false}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          1
          
              channel = current_user.channels.new params[:gateway]
        
      
        

          1
          
              if channel.valid?
        
      
        

          1
          
                channel.save!
        
      
        

          1
          
                current_user.gateway_count += 1
        
      
        

          1
          
                current_user.update_successful_outcome_status
        
      
        

          1
          
                current_user.save!(:validate => false)
        
      
        

          1
          
                render json: channel.as_json
        
      
        

          
          
              else
        
      
        

          
          
                render json: {status: 200, errors: channel.errors.full_messages}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update
        
      
        

          
          
              channel = Channel.find params[:id]
        
      
        

          
          
              channel.update_attributes params[:gateway]
        
      
        

          
          
              render json: channel
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          
          
              channel = Channel.find params[:id]
        
      
        

          
          
              channel.destroy
        
      
        

          
          
              render json: channel 
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def try
        
      
        

          
          
              channel = Channel.find params[:gateway_id]
        
      
        

          
          
              SmsNuntium.notify_sms [params[:phone_number]], 'Welcome to resource map!', channel.nuntium_channel_name, nil
        
      
        

          
          
              render json: channel.as_json
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          1
          
            def status
        
      
        

          1
          
              channel = Channel.find params[:id] 
        
      
        

          1
          
              channel.is_enable = params[:status]
        
      
        

          1
          
              channel.save!
        
      
        

          1
          
              render json: channel
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class ImportWizardsController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :show_collection_breadcrumb
        
      
        

          1
          
            before_filter :show_properties_breadcrumb
        
      
        

          1
          
            before_filter :authenticate_collection_admin!, only: :logs
        
      
        

          
          
          
        
      
        

          1
          
            expose(:import_job) { ImportJob.last_for current_user, collection }
        
      
        

          1
          
            expose(:failed_import_jobs) { ImportJob.where(collection_id: collection.id).where(status: 'failed').order('id desc').page(params[:page]).per_page(10) }
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              return redirect_to import_in_progress_collection_import_wizard_path(collection) if (import_job && (import_job.status_pending? || import_job.status_in_progress?))
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def upload_csv
        
      
        

          1
          
              begin
        
      
        

          1
          
                ImportWizard.import current_user, collection, params[:file].original_filename, params[:file].read
        
      
        

          1
          
                redirect_to adjustments_collection_import_wizard_path(collection)
        
      
        

          
          
              rescue => ex
        
      
        

          
          
                redirect_to collection_import_wizard_path(collection), :alert => ex.message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def guess_columns_spec
        
      
        

          
          
              render json: ImportWizard.guess_columns_spec(current_user, collection), :root =>false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def adjustments
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def validate_sites_with_columns
        
      
        

          
          
              render json: ImportWizard.validate_sites_with_columns(current_user, collection, JSON.parse(params[:columns]))
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def execute
        
      
        

          1
          
              columns = params[:columns].values
        
      
        

          5
          
              if columns.find { |x| x[:usage] == 'new_field' } and not current_user.admins? collection
        
      
        

          1
          
                render text: I18n.t('views.import_wizards.cant_create_new_fields'), status: :unauthorized
        
      
        

          
          
              else
        
      
        

          
          
                ImportWizard.enqueue_job current_user, collection, params[:columns].values
        
      
        

          
          
                render json: :ok
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def import_in_progress
        
      
        

          
          
              redirect_to import_finished_collection_import_wizard_path(collection) if import_job.status_finished?
        
      
        

          
          
          
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def import_finished
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def import_failed
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def cancel_pending_jobs
        
      
        

          
          
              ImportWizard.cancel_pending_jobs(current_user, collection)
        
      
        

          
          
              flash[:notice] = I18n.t('views.import_wizards.import_canceled')
        
      
        

          
          
              redirect_to collection_import_wizard_path
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def job_status
        
      
        

          
          
              render json: {:status => import_job.status}
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def logs
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.import_wizard'), collection_import_wizard_path(collection)
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class LayersController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :authenticate_collection_admin!, :except => [:index]
        
      
        

          1
          
            before_filter :fix_field_config, only: [:create, :update]
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              layers # signal that layers will be used on this page (loaded by ajax later)
        
      
        

          
          
              respond_to do |format|
        
      
        

          
          
                format.html do
        
      
        

          
          
                  show_collection_breadcrumb
        
      
        

          
          
                  add_breadcrumb "Properties", collection_path(collection)
        
      
        

          
          
                  add_breadcrumb "Layers", collection_layers_path(collection)
        
      
        

          
          
                end
        
      
        

          
          
                format.json { render_json collection.layers_to_json(current_user_snapshot.at_present?, current_user) }
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          2
          
              layer = layers.new params[:layer]
        
      
        

          2
          
              layer.collection_id = params[:collection_id]
        
      
        

          2
          
              layer.user = current_user
        
      
        

          2
          
              layer.save!
        
      
        

          2
          
              current_user.layer_count += 1
        
      
        

          2
          
              current_user.update_successful_outcome_status
        
      
        

          2
          
              current_user.save!(:validate => false)
        
      
        

          2
          
              render json: layer.as_json(include: :fields)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update
        
      
        

          
          
              # FIX: For some reason using the exposed layer here results in duplicated fields being created
        
      
        

          1
          
              layer = collection.layers.find params[:id]
        
      
        

          1
          
              fix_layer_fields_for_update layer
        
      
        

          1
          
              layer.user = current_user
        
      
        

          1
          
              layer.update_attributes! params[:layer]
        
      
        

          1
          
              layer.reload
        
      
        

          1
          
              render json: layer.as_json(include: :fields)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_order
        
      
        

          
          
              layer.user = current_user
        
      
        

          
          
              layer.update_attributes! ord: params[:ord]
        
      
        

          
          
              render json: layer
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          
          
          
        
      
        

          
          
              if params['threshold_ids']
        
      
        

          
          
                Threshold.delete(params['threshold_ids'])
        
      
        

          
          
                collection.recreate_index
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              layer.user = current_user
        
      
        

          
          
              layer.destroy
        
      
        

          
          
              head :ok
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def upload_layers
        
      
        

          
          
              path = File.join('public', 'tmp_layers.json')
        
      
        

          
          
              content = params[:file].read
        
      
        

          
          
              File.open(path, "wb") { |f| f.write(content) }
        
      
        

          
          
              begin
        
      
        

          
          
                layers = JSON.parse content
        
      
        

          
          
                flash[:notice] = "File uploaded"
        
      
        

          
          
                redirect_to :action => "adjust_layers"
        
      
        

          
          
              rescue Exception => e
        
      
        

          
          
                flash[:alert] = "Invalid file content"
        
      
        

          
          
                redirect_to :action => "index"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def adjust_layers
        
      
        

          
          
              show_collection_breadcrumb
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.index.properties'), collection_path(collection)
        
      
        

          
          
              add_breadcrumb I18n.t('views.collections.tab.layers'), collection_layers_path(collection)    
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def pending_layers
        
      
        

          
          
              path = File.join('public', 'tmp_layers.json')
        
      
        

          
          
              all_new_layers = []
        
      
        

          
          
              if File.exist?(path)
        
      
        

          
          
                raw_layers = File.read(path, :encoding => 'utf-8')
        
      
        

          
          
                all_layers = JSON.parse raw_layers
        
      
        

          
          
                File.delete(path)
        
      
        

          
          
                all_layers.each do |l|
        
      
        

          
          
                  result = layer.decode_raw_layer l
        
      
        

          
          
                  new_layer = layers.new result
        
      
        

          
          
                  new_layer.user = current_user
        
      
        

          
          
                  all_new_layers.push(new_layer.as_json(include: :fields.as_json(:except => [:id]), :except => [:id, :ord]))
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              render json: all_new_layers
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          
          
            # The options come as a hash insted of a list, so we convert the hash to a list
        
      
        

          
          
            # Also fix hierarchy in the same way.
        
      
        

          1
          
            def fix_field_config
        
      
        

          3
          
              if params[:layer] && params[:layer][:fields_attributes]
        
      
        

          2
          
                params[:layer][:fields_attributes].each do |field_idx, field|
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          2
          
                  if field[:config]
        
      
        

          1
          
                    if field[:config][:locations]
        
      
        

          1
          
                      field[:config][:locations] = field[:config][:locations].values
        
      
        

          
          
                    end          
        
      
        

          1
          
                    if field[:config][:options]
        
      
        

          
          
                      field[:config][:options] = field[:config][:options].values
        
      
        

          
          
                      field[:config][:options].each { |option| option['id'] = option['id'].to_i }
        
      
        

          
          
                    end
        
      
        

          1
          
                    field[:config][:next_id] = field[:config][:next_id].to_i if field[:config][:next_id]
        
      
        

          1
          
                    if field[:config][:hierarchy]
        
      
        

          
          
                      field[:config][:hierarchy] = field[:config][:hierarchy].values
        
      
        

          
          
                      sanitize_items field[:config][:hierarchy]
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          1
          
                    if field[:is_enable_field_logic] == "false"
        
      
        

          1
          
                      params[:layer][:fields_attributes][field_idx][:config] = params[:layer][:fields_attributes][field_idx][:config].except(:field_logics)
        
      
        

          
          
                    end        
        
      
        

          
          
          
        
      
        

          1
          
                    if field[:config][:field_logics]
        
      
        

          
          
                      field[:config][:field_logics] = field[:config][:field_logics].values
        
      
        

          
          
                      field[:config][:field_logics].each { |field_logic| 
        
      
        

          
          
                        field_logic['id'] = field_logic['id'].to_i
        
      
        

          
          
                        field_logic['value'] = field_logic['value'].to_i
        
      
        

          
          
                        if field_logic['field_id']
        
      
        

          
          
                          
        
      
        

          
          
                          if field_logic['field_id'] == ""
        
      
        

          
          
                            field_logic['field_id'] = nil
        
      
        

          
          
                          end
        
      
        

          
          
                        end         
        
      
        

          
          
                      }    
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          1
          
                    field[:config][:range] = fix_field_config_range(field_idx, field) if field[:is_enable_range]
        
      
        

          
          
                    
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def fix_field_config_range(field_idx,field)
        
      
        

          
          
              if field[:is_enable_range] == "false"
        
      
        

          
          
                params[:layer][:fields_attributes][field_idx][:config] = params[:layer][:fields_attributes][field_idx][:config].except(:range)
        
      
        

          
          
              else
        
      
        

          
          
                if field[:config][:range]
        
      
        

          
          
                  if field[:config][:range][:minimum] == "" || field[:config][:range][:minimum].nil?
        
      
        

          
          
                    field[:config][:range] = field[:config][:range].except(:minimum)
        
      
        

          
          
                  else
        
      
        

          
          
                    field[:config][:range][:minimum] = field[:config][:range][:minimum].to_f
        
      
        

          
          
                  end
        
      
        

          
          
                  if field[:config][:range][:maximum] == "" || field[:config][:range][:maximum].nil?
        
      
        

          
          
                    field[:config][:range] = field[:config][:range].except(:maximum)
        
      
        

          
          
                  else
        
      
        

          
          
                    field[:config][:range][:maximum] = field[:config][:range][:maximum].to_f
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end 
        
      
        

          
          
              return field[:config][:range]   
        
      
        

          
          
            end 
        
      
        

          
          
          
        
      
        

          1
          
            def validate_field_logic
        
      
        

          
          
              field[:config][:field_logics].delete_if { |field_logic| !field_logic['layer_id'] }            
        
      
        

          
          
              if field[:config][:field_logics].length == 0
        
      
        

          
          
                params[:layer][:fields_attributes][field_idx][:config] = params[:layer][:fields_attributes][field_idx][:config].except(:field_logics)
        
      
        

          
          
              end    
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def sanitize_items(items)
        
      
        

          
          
              items.each do |item|
        
      
        

          
          
                if item[:sub]
        
      
        

          
          
                  item[:sub] = item[:sub].values
        
      
        

          
          
                  sanitize_items item[:sub]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Instead of sending the _destroy flag to destroy fields (complicates things on the client side code)
        
      
        

          
          
            # we check which are the current fields ids, which are the new ones and we delete those fields
        
      
        

          
          
            # whose ids don't show up in the new ones and then we add the _destroy flag.
        
      
        

          
          
            #
        
      
        

          
          
            # That way we preserve existing fields and we can know if their codes change, to trigger a reindex
        
      
        

          1
          
            def fix_layer_fields_for_update layer
        
      
        

          1
          
              fields = layer.fields
        
      
        

          
          
          
        
      
        

          1
          
              fields_ids = fields.map(&:id).compact
        
      
        

          2
          
              new_ids = params[:layer][:fields_attributes].values.map { |x| x[:id].try(:to_i) }.compact
        
      
        

          1
          
              removed_fields_ids = fields_ids - new_ids
        
      
        

          
          
          
        
      
        

          1
          
              max_key = params[:layer][:fields_attributes].keys.map(&:to_i).max
        
      
        

          1
          
              max_key += 1
        
      
        

          
          
          
        
      
        

          1
          
              removed_fields_ids.each do |id|
        
      
        

          
          
                params[:layer][:fields_attributes][max_key.to_s] = {id: id, _destroy: true}
        
      
        

          
          
                max_key += 1
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              params[:layer][:fields_attributes] = params[:layer][:fields_attributes].values
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_associated_field_threshold_ids(field)
        
      
        

          
          
              associated_field_threshold_ids = []
        
      
        

          
          
              fieldID = field["id"]
        
      
        

          
          
          
        
      
        

          
          
              self.collection.thresholds.map { |threshold|
        
      
        

          
          
                threshold.conditions.map { |condition| 
        
      
        

          
          
                  conditionFieldID = condition['field'].to_i
        
      
        

          
          
                  if fieldID == conditionFieldID
        
      
        

          
          
                    associated_field_threshold_ids.push(threshold.id)
        
      
        

          
          
                    break
        
      
        

          
          
                  end
        
      
        

          
          
                }
        
      
        

          
          
              }
        
      
        

          
          
          
        
      
        

          
          
              associated_field_threshold_ids
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class MembershipsController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :authenticate_collection_admin!, :only => [:create, :set_layer_access, :set_admin, :unset_admin, :index]
        
      
        

          
          
            
        
      
        

          1
          
            include ApplicationHelper 
        
      
        

          
          
            
        
      
        

          1
          
            def index
        
      
        

          
          
              layer_memberships = collection.layer_memberships.all.inject({}) do |hash, membership|
        
      
        

          
          
                (hash[membership.user_id] ||= []) << membership
        
      
        

          
          
                hash
        
      
        

          
          
              end
        
      
        

          
          
              memberships = collection.memberships.includes([:user, :read_sites_permission, :write_sites_permission]).all.map do |membership|
        
      
        

          
          
                user_display_name = User.generate_user_display_name membership.user
        
      
        

          
          
                if user_display_name == membership.user.phone_number
        
      
        

          
          
                  user_phone_number = ""
        
      
        

          
          
                else
        
      
        

          
          
                  user_phone_number = membership.user.phone_number
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                {
        
      
        

          
          
                  user_id: membership.user_id,
        
      
        

          
          
                  user_display_name: user_display_name,
        
      
        

          
          
                  user_phone_number: user_phone_number,
        
      
        

          
          
                  admin: membership.admin?,
        
      
        

          
          
                  layers: (layer_memberships[membership.user_id] || []).map{|x| {layer_id: x.layer_id, read: x.read?, write: x.write?}},
        
      
        

          
          
                  sites: {
        
      
        

          
          
                    none: membership.none_sites_permission,
        
      
        

          
          
                    read: membership.read_sites_permission,
        
      
        

          
          
                    write: membership.write_sites_permission
        
      
        

          
          
                  }
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
              render json: memberships, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          
          
              user = User.find_by_email params[:email]
        
      
        

          
          
              if user && !user.memberships.where(:collection_id => collection.id).exists?
        
      
        

          
          
                user.memberships.create! :collection_id => collection.id
        
      
        

          
          
                render json: {status: :added, user_id: user.id, user_display_name: user.display_name}
        
      
        

          
          
              else
        
      
        

          
          
                register_new_member
        
      
        

          
          
                #render json: {status: :not_added}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def invitable
        
      
        

          
          
              users = User.
        
      
        

          
          
                where('email LIKE ?', "#{params[:term]}%").
        
      
        

          
          
                where("id not in (?)", collection.memberships.pluck(:user_id)).
        
      
        

          
          
                order('email')
        
      
        

          
          
              render json: users.pluck(:email), :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search
        
      
        

          3
          
              users = User.
        
      
        

          
          
                where('email LIKE ?', "#{params[:term]}%").
        
      
        

          
          
                where("id in (?)", collection.memberships.pluck(:user_id)).
        
      
        

          
          
                order('email')
        
      
        

          
          
          
        
      
        

          3
          
              render json: users.pluck(:email), :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          
          
              membership = collection.memberships.find_by_user_id params[:id]
        
      
        

          
          
              if leave_collection_permission? || membership.user_id != current_user.id
        
      
        

          
          
                membership.destroy
        
      
        

          
          
              end
        
      
        

          
          
              redirect_to collections_path
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_layer_access
        
      
        

          
          
              membership = collection.memberships.find_by_user_id params[:id]
        
      
        

          
          
              membership.set_layer_access params
        
      
        

          
          
              render json: :ok
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def set_admin
        
      
        

          
          
              change_admin_flag true
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def unset_admin
        
      
        

          
          
              change_admin_flag false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def register_new_member
        
      
        

          
          
              if (params[:user][:email].strip.length == 0)
        
      
        

          
          
                params[:user][:email] = User.generate_default_email
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              params[:user][:password] = User.generate_random_password if params[:user]
        
      
        

          
          
              if (User.find_all_by_phone_number(params[:user][:phone_number]).count == 0)
        
      
        

          
          
                user = User.create params[:user] if params[:user]    
        
      
        

          
          
                user.confirmed_at = Time.now
        
      
        

          
          
                if user.save!
        
      
        

          
          
                  user = User.find_by_email params[:user][:email]
        
      
        

          
          
                  user.memberships.create! admin: false, user_id: user.id, collection_id: collection.id
        
      
        

          
          
                  membership = collection.memberships.find_by_user_id user.id
        
      
        

          
          
                  user_display_name = User.generate_user_display_name user  
        
      
        

          
          
                  if membership
        
      
        

          
          
                    collection.layers.each do |l|
        
      
        

          
          
                      membership.set_layer_access :access => true, :layer_id => l.id, :verb => "read"
        
      
        

          
          
                    end 
        
      
        

          
          
                  end
        
      
        

          
          
                  layer_memberships = collection.layer_memberships.all.inject({}) do |hash, membership|
        
      
        

          
          
                    (hash[membership.user_id] ||= []) << membership
        
      
        

          
          
                    hash
        
      
        

          
          
                  end
        
      
        

          
          
                  render json: {
        
      
        

          
          
                                status: :ok, 
        
      
        

          
          
                                user_id: user.id,
        
      
        

          
          
                                layers: (layer_memberships[membership.user_id] || []).map{|x| {layer_id: x.layer_id, read: x.read?, write: x.write?}}, 
        
      
        

          
          
                                user_display_name: user_display_name
        
      
        

          
          
                                } 
        
      
        

          
          
                else
        
      
        

          
          
                  render json: :unsaved
        
      
        

          
          
                end
        
      
        

          
          
              else
        
      
        

          
          
                render json: {status: :phone_existed}
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def change_admin_flag(new_value)
        
      
        

          
          
              membership = collection.memberships.find_by_user_id params[:id]
        
      
        

          
          
              membership.admin = new_value
        
      
        

          
          
              membership.save!
        
      
        

          
          
          
        
      
        

          
          
              render json: :ok
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          require 'treetop_dependencies'
        
      
        

          1
          
          require 'digest'
        
      
        

          
          
          
        
      
        

          1
          
          class NuntiumController < ApplicationController
        
      
        

          1
          
            helper_method :save_message
        
      
        

          1
          
            protect_from_forgery :except => :receive
        
      
        

          1
          
            before_filter :set_timezone, :except => [:receive, :authenticate]
        
      
        

          
          
          
        
      
        

          1
          
            USER_NAME, PASSWORD = 'iLab', '1c4989610bce6c4879c01bb65a45ad43'
        
      
        

          
          
          
        
      
        

          
          
            # POST /messaging
        
      
        

          
          
            # def index
        
      
        

          
          
              # raise HttpVerbNotSupported.new unless request.post?
        
      
        

          
          
              # message = save_message
        
      
        

          
          
              # begin
        
      
        

          
          
                # message.process! params
        
      
        

          
          
              # rescue => err
        
      
        

          
          
                # message.reply = err.message
        
      
        

          
          
              # ensure
        
      
        

          
          
              # if (message.reply != "Invalid command")
        
      
        

          
          
                # message[:collection_id] = get_collection_id(params[:body])
        
      
        

          
          
              # end
        
      
        

          
          
              # message.save
        
      
        

          
          
              # render :text => message.reply, :content_type => "text/plain"
        
      
        

          
          
              # end
        
      
        

          
          
            # end
        
      
        

          
          
            
        
      
        

          
          
            # POST /nuntium
        
      
        

          1
          
            def receive
        
      
        

          7
          
              begin
        
      
        

          7
          
                message = save_message
        
      
        

          
          
              rescue => err
        
      
        

          4
          
                render :text => err.message, :status => 400
        
      
        

          4
          
                return
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          3
          
              begin
        
      
        

          3
          
                message.process! params
        
      
        

          
          
              rescue => err
        
      
        

          
          
                message.reply = err.message
        
      
        

          
          
              ensure
        
      
        

          3
          
              if (message.reply != "Invalid command")
        
      
        

          3
          
                collection_id = get_collection_id(params[:body])
        
      
        

          3
          
                if collection_id and collection_id >0
        
      
        

          3
          
                  message[:collection_id] = collection_id
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          3
          
              message.save
        
      
        

          3
          
              render :text => message.reply, :content_type => "text/plain"
        
      
        

          3
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def authenticate
        
      
        

          2
          
              authenticate_or_request_with_http_basic 'Dynamic Resource Map - HTTP' do |username, password|
        
      
        

          1
          
                USER_NAME == username && PASSWORD == Digest::MD5.hexdigest(password)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def get_collection_id(bodyMsg)
        
      
        

          3
          
              if (bodyMsg[5] == "q")
        
      
        

          
          
                collectionId = Message.getCollectionId(bodyMsg, 7)
        
      
        

          3
          
              elsif (bodyMsg[5] == "u")
        
      
        

          3
          
                siteCode = Message.getCollectionId(bodyMsg, 7)
        
      
        

          3
          
                site = Site.find_by_id_with_prefix(siteCode)
        
      
        

          3
          
                if site
        
      
        

          3
          
                  collectionId = site.collection_id
        
      
        

          
          
                else
        
      
        

          
          
                  collectionId = -1
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          3
          
              return collectionId
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def save_message
        
      
        

          5
          
              Message.create!(:guid => params[:guid], :from => params[:from], :body => params[:body]) do |m|
        
      
        

          4
          
                m.country = params[:country]
        
      
        

          4
          
                m.carrier = params[:carrier]
        
      
        

          4
          
                m.channel = params[:channel]
        
      
        

          4
          
                m.application = params[:application]
        
      
        

          4
          
                m.to = params[:to]
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class QuotasController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            def index
        
      
        

          
          
              @collections = Collection.all
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          1
          
              collection = Collection.find params["collection_id"]
        
      
        

          1
          
              collection.quota = collection.quota + params["quota"].to_i
        
      
        

          1
          
              collection.save!
        
      
        

          1
          
              redirect_to quotas_path
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          1
          
            def show
        
      
        

          1
          
              collection = Collection.find params["id"]
        
      
        

          1
          
              render :json => collection
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class SitesController < ApplicationController
        
      
        

          25
          
            before_filter :setup_guest_user, :if => Proc.new { collection && collection.public }
        
      
        

          25
          
            before_filter :authenticate_user!, :except => [:index, :search, :search_alert_site], :unless => Proc.new { collection && collection.public }
        
      
        

          
          
          
        
      
        

          1
          
            authorize_resource :only => [:index, :search, :search_alert_site], :decent_exposure => true
        
      
        

          
          
          
        
      
        

          1
          
            expose(:sites) {if !current_user_snapshot.at_present? && collection then collection.site_histories.at_date(current_user_snapshot.snapshot.date) else collection.sites end}
        
      
        

          12
          
            expose(:site) { Site.find(params[:site_id] || params[:id]) }
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          
          
              search = new_search
        
      
        

          
          
          
        
      
        

          
          
              search.name_start_with params[:name] if params[:name].present?
        
      
        

          
          
              search.alerted_search params[:_alert] if params[:_alert] == "true"
        
      
        

          
          
              search.offset params[:offset] if params[:offset].present?
        
      
        

          
          
              search.limit params[:limit] if params[:limit].present?
        
      
        

          
          
          
        
      
        

          
          
              #hierarchy mode display
        
      
        

          
          
              if !(params[:limit] && params[:offset])
        
      
        

          
          
                search.unlimited
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              render json: search.ui_results.map { |x| x['_source'] }, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def show
        
      
        

          
          
              search = new_search
        
      
        

          
          
          
        
      
        

          
          
              search.id params[:id]
        
      
        

          
          
              # If site does not exists, return empty objects
        
      
        

          
          
              result = search.ui_results.first['_source'] rescue {}
        
      
        

          
          
          
        
      
        

          
          
              render json: result
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          2
          
              site_params = JSON.parse params[:site]
        
      
        

          2
          
              ui_attributes = prepare_from_ui(site_params)
        
      
        

          2
          
              site = collection.sites.new(ui_attributes.merge(user: current_user))
        
      
        

          2
          
              if site.valid?
        
      
        

          2
          
                site.save!
        
      
        

          2
          
                current_user.site_count += 1
        
      
        

          2
          
                current_user.update_successful_outcome_status
        
      
        

          2
          
                current_user.save!(:validate => false)
        
      
        

          2
          
                render json: site, :layout => false
        
      
        

          
          
              else
        
      
        

          
          
                render json: site.errors.messages, status: :unprocessable_entity, :layout => false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update
        
      
        

          2
          
              site_params = JSON.parse params[:site]
        
      
        

          2
          
              site.user = current_user
        
      
        

          2
          
              site.properties_will_change!
        
      
        

          2
          
              site.attributes = prepare_from_ui(site_params)
        
      
        

          2
          
              if site.valid?
        
      
        

          2
          
                site.save!
        
      
        

          2
          
                if params[:photosToRemove]
        
      
        

          
          
                  Site::UploadUtils.purgePhotos(params[:photosToRemove])
        
      
        

          
          
                end
        
      
        

          2
          
                render json: site, :layout => false
        
      
        

          
          
              else
        
      
        

          
          
                render json: site.errors.messages, status: :unprocessable_entity, :layout => false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def update_property
        
      
        

          19
          
              field = site.collection.fields.where_es_code_is params[:es_code]
        
      
        

          19
          
              if not site.collection.site_ids_permission(current_user).include? site.id
        
      
        

          19
          
                return head :forbidden unless current_user.can_write_field? field, site.collection, params[:es_code]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          19
          
              site.user = current_user
        
      
        

          19
          
              site.properties_will_change!
        
      
        

          
          
          
        
      
        

          19
          
              site.properties[params[:es_code]] = field.decode_from_ui(params[:value])
        
      
        

          19
          
              if site.valid?
        
      
        

          10
          
                site.save!
        
      
        

          10
          
                render json: site, :status => 200, :layout => false
        
      
        

          
          
              else
        
      
        

          9
          
                error_message = site.errors[:properties][0][params[:es_code]]
        
      
        

          9
          
                render json: {:error_message => error_message}, status: :unprocessable_entity, :layout => false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search
        
      
        

          
          
              zoom = params[:z].to_i
        
      
        

          
          
          
        
      
        

          
          
              if params[:collection_ids].is_a? String
        
      
        

          
          
                collection_ids_array = params[:collection_ids].split ","
        
      
        

          
          
              elsif params[:collection_ids].is_a? Array
        
      
        

          
          
                collection_ids_array = params[:collection_ids]
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              search = MapSearch.new collection_ids_array, user: current_user
        
      
        

          
          
          
        
      
        

          
          
              search.zoom = zoom
        
      
        

          
          
              search.bounds = params if zoom >= 2
        
      
        

          
          
              search.exclude_id params[:exclude_id].to_i if params[:exclude_id].present?
        
      
        

          
          
              search.after params[:updated_since] if params[:updated_since]
        
      
        

          
          
              search.full_text_search params[:search] if params[:search].present?
        
      
        

          
          
              search.alerted_search params[:_alert] if params[:_alert].present?
        
      
        

          
          
              search.location_missing if params[:location_missing].present?
        
      
        

          
          
              search.name_search params[:sitename] if params[:sitename].present?
        
      
        

          
          
              search.hierarchy_mode params[:selected_site_children] if params[:selected_site_parent].present?
        
      
        

          
          
              if params[:selected_hierarchies].present?
        
      
        

          
          
                search.selected_hierarchy params[:hierarchy_code], params[:selected_hierarchies]
        
      
        

          
          
              end
        
      
        

          
          
              search.where params.except(:selected_site_children, :selected_site_parent, :action,
        
      
        

          
          
                    :controller, :format, :n, :s, :e, :w, :z, :collection_ids, :exclude_id,
        
      
        

          
          
                    :updated_since, :search, :location_missing, :hierarchy_code,
        
      
        

          
          
                    :selected_hierarchies, :_alert)
        
      
        

          
          
          
        
      
        

          
          
              render_json search.results, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def search_alert_site
        
      
        

          
          
              zoom = params[:z].to_i
        
      
        

          
          
          
        
      
        

          
          
              search = MapSearch.new params[:collection_ids], user: current_user
        
      
        

          
          
          
        
      
        

          
          
              search.zoom = zoom
        
      
        

          
          
              search.bounds = params if zoom >= 2
        
      
        

          
          
              search.exclude_id params[:exclude_id].to_i if params[:exclude_id].present?
        
      
        

          
          
              search.after params[:updated_since] if params[:updated_since]
        
      
        

          
          
              search.full_text_search params[:search] if params[:search].present?
        
      
        

          
          
              search.alerted_search params[:_alert] if params[:_alert].present?
        
      
        

          
          
              search.location_missing if params[:location_missing].present?
        
      
        

          
          
              if params[:selected_hierarchies].present?
        
      
        

          
          
                search.selected_hierarchy params[:hierarchy_code], params[:selected_hierarchies]
        
      
        

          
          
              end
        
      
        

          
          
              search.where params.except(:selected_site_children, :selected_site_parent, :action, :controller, :format, :n, :s, :e, :w, :z, :collection_ids, :exclude_id, :updated_since, :search, :location_missing, :hierarchy_code, :selected_hierarchies, :_alert)
        
      
        

          
          
          
        
      
        

          
          
              # search.apply_queries
        
      
        

          
          
              # render json: search.sites_json
        
      
        

          
          
              render_json search.sites_json, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def destroy
        
      
        

          1
          
              site.user = current_user
        
      
        

          1
          
              Site::UploadUtils.purgeUploadedPhotos(site)
        
      
        

          1
          
              site.destroy
        
      
        

          1
          
              render json: site, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def visible_layers_for
        
      
        

          
          
              layers = []
        
      
        

          
          
              if site.collection.site_ids_permission(current_user).include? site.id
        
      
        

          
          
                target_fields = fields.includes(:layer).all
        
      
        

          
          
                layers = target_fields.map(&:layer).uniq.map do |layer|
        
      
        

          
          
                  {
        
      
        

          
          
                    id: layer.id,
        
      
        

          
          
                    name: layer.name,
        
      
        

          
          
                    ord: layer.ord,
        
      
        

          
          
                  }
        
      
        

          
          
                end
        
      
        

          
          
                if site.collection.site_ids_write_permission(current_user).include? site.id
        
      
        

          
          
                  layers.each do |layer|
        
      
        

          
          
                    layer[:fields] = target_fields.select { |field| field.layer_id == layer[:id] }
        
      
        

          
          
                    layer[:fields].map! do |field|
        
      
        

          
          
                      {
        
      
        

          
          
                        id: field.es_code,
        
      
        

          
          
                        name: field.name,
        
      
        

          
          
                        code: field.code,
        
      
        

          
          
                        kind: field.kind,
        
      
        

          
          
                        config: field.config,
        
      
        

          
          
                        ord: field.ord,
        
      
        

          
          
                        writeable: true
        
      
        

          
          
                      }
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                elsif site.collection.site_ids_read_permission(current_user).include? site.id
        
      
        

          
          
                  layers.each do |layer|
        
      
        

          
          
                    layer[:fields] = target_fields.select { |field| field.layer_id == layer[:id] }
        
      
        

          
          
                    layer[:fields].map! do |field|
        
      
        

          
          
                      {
        
      
        

          
          
                        id: field.es_code,
        
      
        

          
          
                        name: field.name,
        
      
        

          
          
                        code: field.code,
        
      
        

          
          
                        kind: field.kind,
        
      
        

          
          
                        config: field.config,
        
      
        

          
          
                        ord: field.ord,
        
      
        

          
          
                        writeable: false
        
      
        

          
          
                      }
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                layers.sort! { |x, y| x[:ord] <=> y[:ord] }
        
      
        

          
          
              else
        
      
        

          
          
                layers = site.collection.visible_layers_for(current_user)
        
      
        

          
          
              end
        
      
        

          
          
              render json: layers, :root => false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            private
        
      
        

          
          
          
        
      
        

          1
          
            def prepare_from_ui(parameters)
        
      
        

          4
          
              fields = collection.fields.index_by(&:es_code)
        
      
        

          4
          
              decoded_properties = {}
        
      
        

          4
          
              site_properties = parameters.delete("properties") || {}
        
      
        

          4
          
              files = params[:fileUpload] || {}
        
      
        

          
          
          
        
      
        

          4
          
              site_properties.each_pair do |es_code, value|
        
      
        

          10
          
                value = [ value, files[value] ] if fields[es_code].kind == 'photo'
        
      
        

          10
          
                decoded_properties[es_code] = fields[es_code].decode_from_ui(value)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          4
          
              parameters["properties"] = decoded_properties unless decoded_properties.blank?
        
      
        

          4
          
              parameters
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          class SitesPermissionController < ApplicationController
        
      
        

          1
          
            before_filter :authenticate_user!
        
      
        

          1
          
            before_filter :authenticate_collection_admin!, only: :create
        
      
        

          
          
          
        
      
        

          6
          
            before_filter :setup_guest_user, :if => Proc.new { collection && collection.public }
        
      
        

          6
          
            before_filter :authenticate_user!, :unless => Proc.new { collection && collection.public }
        
      
        

          
          
          
        
      
        

          1
          
            def index
        
      
        

          8
          
              membership = current_user.memberships.find{|m| m.collection_id == params[:collection_id].to_i}
        
      
        

          4
          
              render json: membership.try(:sites_permission) || SitesPermission.no_permission
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def create
        
      
        

          1
          
              membership = collection.memberships.find_by_user_id params[:sites_permission].delete :user_id
        
      
        

          1
          
              membership.update_sites_permission params[:sites_permission]
        
      
        

          
          
          
        
      
        

          1
          
              render json: :ok
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module Api::GeoJsonHelper
        
      
        

          1
          
            def collection_geo_json(collection, results)
        
      
        

          
          
              root = {}
        
      
        

          
          
              root[:type] = 'Feature'
        
      
        

          
          
              root[:geometry] = nil
        
      
        

          
          
              root[:properties] = (props = {features: (features = {})})
        
      
        

          
          
          
        
      
        

          
          
              props[:name] = collection.name
        
      
        

          
          
              props[:previousPage] = url_for(params.merge page: results.previous_page, only_path: false) if results.previous_page
        
      
        

          
          
              props[:nextPage] = url_for(params.merge page: results.next_page, only_path: false) if results.next_page
        
      
        

          
          
              props[:count] = results.total
        
      
        

          
          
              props[:totalPages] = results.total_pages
        
      
        

          
          
          
        
      
        

          
          
              features[:type] = 'FeatureCollection'
        
      
        

          
          
              features[:features] = results.map { |result| site_item_geo_json result }
        
      
        

          
          
          
        
      
        

          
          
              root
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def site_item_geo_json(result)
        
      
        

          
          
              source = result['_source']
        
      
        

          
          
          
        
      
        

          
          
              obj = {}
        
      
        

          
          
              obj[:type] = 'Feature'
        
      
        

          
          
              obj[:geometry] = {type: 'Point', coordinates: [source['location']['lon'], source['location']['lat']]}
        
      
        

          
          
              obj[:id] = source['id']
        
      
        

          
          
              obj[:properties] = (props = {})
        
      
        

          
          
          
        
      
        

          
          
              props[:name] = source['name']
        
      
        

          
          
              props[:createdAt] = Site.parse_time(source['created_at'])
        
      
        

          
          
              props[:updatedAt] = Site.parse_time(source['updated_at'])
        
      
        

          
          
              props[:properties] = source['properties']
        
      
        

          
          
          
        
      
        

          
          
              obj
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
    
  

    

      
        

          1
          
          module Api::JsonHelper
        
      
        

          1
          
            def collection_json(collection, results)
        
      
        

          4
          
              obj = {}
        
      
        

          4
          
              obj[:id] = collection.id
        
      
        

          4
          
              obj[:name] = collection.name
        
      
        

          4
          
              obj[:is_visible_location] = collection.is_visible_location
        
      
        

          4
          
              obj[:is_visible_name] = collection.is_visible_name
        
      
        

          4
          
              obj[:previousPage] = url_for(params.merge page: results.previous_page, only_path: false) if results.previous_page
        
      
        

          4
          
              obj[:nextPage] = url_for(params.merge page: results.next_page, only_path: false) if results.next_page
        
      
        

          4
          
              obj[:count] = results.total
        
      
        

          4
          
              obj[:totalPages] = results.total_pages
        
      
        

          10
          
              obj[:sites] = results.map {|result| site_item_json result}
        
      
        

          4
          
              obj
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            def site_item_json(result)
        
      
        

          6
          
              source = result['_source']
        
      
        

          
          
          
        
      
        

          6
          
              obj = {}
        
      
        

          6
          
              obj[:id] = source['id']
        
      
        

          6
          
              obj[:name] = source['name']
        
      
        

          6
          
              obj[:createdAt] = Site.parse_time(source['created_at'])
        
      
        

          6
          
              obj[:updatedAt] = Site.parse_time(source['updated_at'])
        
      
        

          
          
          
        
      
        

          6
          
              if source['location']
        
      
        

          6
          
                obj[:lat] = source['location']['lat']
        
      
        

          6
          
                obj[:long] = source['location']['lon']
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          6
          
              source['properties'].each do |key, property|
        
      
        

          30
          
                field = Field.find_by_code(key)
        
      
        

          30
          
                if field.kind == 'photo'
        
      
        

          
          
                  source['properties'][key] = "#{Settings.host}/photo_field/#{property}"
        
      
        

          
          
                  break
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          6
          
              obj[:properties] = source['properties']
        
      
        

          
          
          
        
      
        

          6
          
              obj
        
      
        

          
          
            end
        
      
        

          
          
          end